package com.qinyeit.serviceapp.utils;

import java.math.BigDecimal;

public class CompuUtils {
    /**小数点后保留的位数*/
    public static final int SCALE = 5;
    /** 0 */
    public static final int ZERO = 0;


    /**
     * BigDecimal大小比较
     *
     * @param a
     * @param b
     * @return 返回1， 表示a大于b <br/>
     *                  返回0 ，表示a等于b <br/>
     *         返回-1，表示a小于b
     * @author jqlin
     */
    public static int compareTo(BigDecimal a, BigDecimal b){
        return a.compareTo(b);
    }

    /**
     * double大小比较
     *
     * @param a
     * @param b
     * @return 返回1， 表示a大于b <br/>
     *                  返回0 ，表示a等于b <br/>
     *         返回-1，表示a小于b
     * @author jqlin
     */
    public static int compareTo(double a, double b){
        return compareTo(String.valueOf(a), String.valueOf(b));
    }

    /**
     * float大小比较
     *
     * @param a
     * @param b
     * @return 返回1， 表示a大于b <br/>
     *                  返回0 ，表示a等于b <br/>
     *         返回-1，表示a小于b
     * @author jqlin
     */
    public static int compareTo(float a, float b){
        return compareTo(String.valueOf(a), String.valueOf(b));
    }


    /**
     * 数值大小比较
     *
     * @param a
     * @param b
     * @return 返回1， 表示a大于b <br/>
     *                  返回0 ，表示a等于b <br/>
     *         返回-1，表示a小于b
     * @author jqlin
     */
    public static int compareTo(String a, String b){
        return compareTo(new BigDecimal(a), new BigDecimal(b));
    }

    /**
     * 累加运算
     *
     * @param scale
     * @param vals 小数点后保留几位
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static BigDecimal add(int scale, BigDecimal... vals) {
        if(vals == null || vals.length <= 0){
            return null;
        }

        BigDecimal sum = new BigDecimal("0");
        for(BigDecimal val : vals){
            sum = sum.add(val);
        }

        return sum.setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 累加运算
     *
     * @param vals
     * @return
     * @author jqlin
     */
    public static int add(int... vals) {
        if(vals == null || vals.length <= 0){
            return 0;
        }

        int sum = 0;
        for(int val : vals){
            sum = sum + val;
        }

        return sum;
    }

    /**
     * 累加运算
     *
     * @param scale
     * @param vals 小数点后保留几位
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static double add(int scale, double... vals) {
        if(vals == null || vals.length <= 0){
            return 0;
        }

        BigDecimal sum = new BigDecimal("0");
        for(double val : vals){
            sum = sum.add(new BigDecimal(val));
        }

        return sum.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 累加运算
     *
     * @param scale
     * @param vals 小数点后保留几位
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static float add(int scale, float... vals) {
        if(vals == null || vals.length <= 0){
            return 0;
        }

        BigDecimal sum = new BigDecimal("0");
        for(float val : vals){
            sum = sum.add(new BigDecimal(val));
        }

        return sum.setScale(scale, BigDecimal.ROUND_HALF_UP).floatValue();
    }
    /**
     * 加法运算
     *
     * @param a 被加数
     * @param b 加数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static BigDecimal add(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        return a.add(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 加法运算
     *
     * @param a 被加数
     * @param b 加数
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static BigDecimal add(BigDecimal a, BigDecimal b) {
        return  add(a, b, SCALE);
    }

    /**
     * 加法运算
     *
     * @param a 被加数
     * @param b 加数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static double add(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }

        return add(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
    }

    /**
     * 加法运算
     *
     * @param a 被加数
     * @param b 加数
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static double add(double a, double b) {
        return add(new BigDecimal(a), new BigDecimal(b), SCALE).doubleValue();
    }

    /**
     * 减法运算
     *
     * @param a 被减数
     * @param b 减数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static BigDecimal subtract(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        return a.subtract(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 减法运算
     *
     * @param a 被减数
     * @param b 减数
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static BigDecimal subtract(BigDecimal a, BigDecimal b) {
        return subtract(a, b, SCALE);
    }

    /**
     * 减法运算
     *
     * @param a 被减数
     * @param b 减数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static double subtract(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }

        return subtract(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
    }

    /**
     * 减法运算
     *
     * @param a 被减数
     * @param b 减数
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static double subtract(double a, double b) {
        return subtract(new BigDecimal(a), new BigDecimal(b), SCALE).doubleValue();
    }

    /**
     * 乘法运算
     *
     * @param a 被乘数
     * @param b 乘数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static BigDecimal multiply(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        return a.multiply(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 乘法运算
     *
     * @param a 被乘数
     * @param b 乘数
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static BigDecimal multiply(BigDecimal a, BigDecimal b) {
        return multiply(a, b, SCALE);
    }

    /**
     * 乘法运算
     *
     * @param a 被乘数
     * @param b 乘数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static double multiply(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }

        return multiply(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
    }

    /**
     * 乘法运算
     *
     * @param a 被乘数
     * @param b 乘数
     * @return 四舍五入后的结果
     * @author jqlin
     */
    public static double multiply(double a, double b) {
        return multiply(a, b, SCALE);
    }


    /**
     * 除法运算
     *
     * @param a 被除数
     * @param b 除数
     * @param scale 保留小数点后多少位, 默认保留5位小数点
     * @return  四舍五入后的结果
     * @author jqlin
     */
    public static BigDecimal divide(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }

        return a.divide(b, scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 除法运算，默认保留5位小数点
     *
     * @param a 被除数
     * @param b 除数
     * @return    四舍五入后的结果
     * @author jqlin
     */
    public static BigDecimal divide(BigDecimal a, BigDecimal b) {
        return divide(a, b, SCALE);
    }

    /**
     * 除法运算
     *
     * @param a 被除数
     * @param b 除数
     * @param scale 保留小数点后多少位, 默认保留5位小数点
     * @return  四舍五入后的结果
     * @author jqlin
     */
    public static double divide(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }

        return divide(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
    }

    /**
     * 除法运算，默认保留5位小数点
     *
     * @param a 被除数
     * @param b 除数
     * @return    四舍五入后的结果
     * @author jqlin
     */
    public static double divide(double a, double b) {
        return divide(a, b, SCALE);
    }
//
//    public static void main(String[] args) {
//        System.out.println(compareTo(new BigDecimal("1.000000000000000000000001"), new BigDecimal("1.000000000000000000000002")));
//        System.out.println(compareTo("1.000000000000000000000001", "1.000000000000000000000002"));
//        System.out.println(compareTo(1.0100010001D, 1.0100010002D));
//        System.out.println(compareTo(1.010001F, 1.010002F));
//
//    }

}
